《设计模式》基本原则：
1.开放封闭原则=》类的改动通过增加代码来实现，而不是修改源代码
2.单一职责原则=》一个类对外只提供一个接口
3.依赖倒置原则=》依赖于抽象，不依赖于具体类
4.接口隔离原则=》应该把用户不需要的接口全部屏蔽
5.里氏替换原则=》任何抽象类出现的地方，都可以用他的实现类来替换
6.多使用组合原则=》这样可以不因为父类的改变而修改子类的实现
7.迪米铁法则=》一个类应该对其他类的联系尽量减少，从来降低耦合性。


一、单例模式
定义：
保证一个类，只有一个实例存在，同时提供可以对该类进行访问的全局方法。

作用：
一般用于：
	1.全局变量来共享资源   
	2.初始化全局socket等资源，这些资源往往只需要初始化一次
	3.在大规模系统中，为了节省对象创建的时间，用此模式来减少对象的创建时间等。
	
实现方法：
	1.构造函数私有化
	2.提供一个全局的访问方法
	3.在类中定义一个静态指针，指向本类的变量的静态变量指针。

//懒汉式   延时创建 效率更高，但需要考虑多线程初始化问题
class Single
{
    private static Single s = null;
    private Single(){}
    public static Single getInstance()
    {
        if(s==null)//这儿使用double-check是为了提升效率，同时防止多次创建内存，如果多个线程调用这个函数，则可能每个线程都进入这个判断里面。
        {
            lock();
			if(s==null)//这儿使用临界区是为了保证单例,防止多次创建, 这次的check是为了判断如果内存已经创建，则直接退出临界区
			{
				m_singer = new Single();
			}
			unLock();
        }
        return s;
    }
}

//饿汉式单例		优点：没有加锁，执行效率会提高，但是浪费内存，加载时就创建实例。
public class Singleton 
{
      private static final Singleton SINGLETON = new Singleton();
      private Singleton() {} //此类不能被实例化
      public static synchronized Singleton getInstance() {
      return SINGLETON;
}

//番外篇 线程创建
1._beginthreadex//线程安全创建，内部调用CreateThread，会自动调用_endthreadex来释放内核资源，但不会关闭线程句柄，需要closehandle手动释放
2._beginthread//CRT运行时库函数，自动调用_endthread，内部会自动调用closehandle来释放线程句柄资源。
3.CreateThread//系统API函数，需要使用closehandle来手动关闭句柄。

二、工厂模式

2.1 简单工厂模式

2.2 工厂方法模式
定义：工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

与简单工厂模式对比：
简单工厂模式：抽象类(作为具体产品类的基类，和负责描述共同接口)、具体产品类、工厂类(根据不同特性创建不同具体产品出来)
工厂方法模式：抽象类(作为具体产品类的基类，提供产品共同接口)，抽象工厂类(作为具体产品工厂类的基类，提供工厂共同接口)，具体产品类，具体产品工厂类

实例：
#include "stdafx.h"
#include "iostream"
using namespace std;

//水果
class Fruit
{
public:
	virtual void sayname()
	{
		cout<<"fruit\n";
	}
};

//水果工厂
class FruitFactory
{
public:
	virtual Fruit* getFruit()
	{
		return new Fruit();
	}
};


//香蕉
class Banana : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"Banana \n"<<endl;
	}
};

//香蕉工厂
class BananaFactory : public  FruitFactory
{
public:
	virtual Fruit* getFruit()
	{
		return new Banana;
	}
};


//苹果
class Apple : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"Apple \n"<<endl;
	}
};

//苹果工厂
class AppleFactory : public  FruitFactory
{
public:
	virtual Fruit* getFruit()
	{
		return new Apple;
	}
};

void main()
{
	FruitFactory * ff  = NULL;
	Fruit *fruit = NULL;

	//1
	ff = new BananaFactory();
	fruit = ff->getFruit();
	fruit->sayname();

	delete fruit;
	delete ff;

	//2苹果
	ff = new AppleFactory();
	fruit = ff->getFruit();
	fruit->sayname();

	delete fruit;
	delete ff;

	cout<<"hello....\n";
	system("pause");
}

2.3 抽象工厂模式
定义：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象，符合开放-封闭原则(需要多添加一个产品族，则只需要添加这个产品族的产品和产品工厂就可以了)

角色职责：
1.	抽象工厂（Creator）
抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

2.	具体工厂（ Concrete  Creator）
具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

3.	抽象（Product）
抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

4.	具体产品（Concrete Product）
抽象模式所创建的具体实例对象
class Fruit
{
public:
	virtual void sayname()
	{
		cout<<"fruit\n";
	}
};

class FruitFactory
{
public:
	virtual Fruit* getApple()
	{
		return new Fruit();
	}
	virtual Fruit* getBanana()
	{
		return new Fruit();
	}
};

//南方香蕉
class SouthBanana : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"South Banana \n"<<endl;
	}
};


//南方苹果
class SouthApple : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"South Apple \n"<<endl;
	}
};


//北方香蕉
class NorthBanana : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"North Banana \n"<<endl;
	}
};


//北方苹果
class NorthApple : public Fruit
{
public:
	virtual void sayname()
	{
		cout<<"North Apple \n"<<endl;
	}
};

//细分 南方水果工厂
class SourthFruitFactory : public FruitFactory
{
public:
	virtual Fruit* getApple()
	{
		return new SouthApple();
	}
	virtual Fruit* getBanana()
	{
		return new SouthBanana();
	}
};

//细分 北方水果工厂
class NorthFruitFactory : public FruitFactory
{
public:
	virtual Fruit* getApple()
	{
		return new NorthApple();
	}
	virtual Fruit* getBanana()
	{
		return new NorthBanana();
	}
};

void main()
{	
	FruitFactory * ff  = NULL;
	Fruit *fruit = NULL;

	ff = new SourthFruitFactory();
	fruit = ff->getApple();
	fruit->sayname();
	fruit = ff->getBanana();
	fruit->sayname();

	delete fruit;
	delete ff;

	ff = new NorthFruitFactory();
	fruit = ff->getApple();
	fruit->sayname();
	fruit = ff->getBanana();
	fruit->sayname();

	delete fruit;
	delete ff;

	cout<<"hello....\n";
	system("pause");
}

三、适配器模式
概念：
Adapter模式也叫适配器模式，是构造型模式之一，通过Adapter模式可以改变已有类（或外部类）的接口形式。

应用场景：
是将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

实例：
#include "stdafx.h"  
#include <iostream>  
using namespace std;  
  
class CurrentAll//需要适配的基类  
{  
public:  
    virtual void useCurrent() = 0;  
};  
  
class Current18v:public CurrentAll//需要适配的类1  
{  
public:  
    void useCurrent()  
    {  
        use18vCurrent();  
    }  
    void use18vCurrent()  
    {  
        cout << "使用18v的交流电" << endl;  
    }  
protected:  
private:  
};  
  
  
class Current220v:public CurrentAll//需要适配的类2  
{  
public:  
    void useCurrent()  
    {  
        use220vCurrent();  
    }  
    void use220vCurrent()  
    {  
        cout << "使用220v的交流电" << endl;  
    }  
protected:  
private:  
};  
  
class Current360v:public CurrentAll//需要适配的类3  
{  
public:  
    void useCurrent()  
    {  
        use360vCurrent();  
    }  
    void use360vCurrent()  
    {  
        cout << "使用360v的交流电" << endl;  
    }  
protected:  
private:  
};  
  
  
class Adapter : public CurrentAll//适配器  
{  
public:  
    Adapter(Current18v *p18v)  
    {  
        m_p = p18v;  
    }  
    Adapter(Current220v *p220v)  
    {  
        m_p = p220v;  
    }  
    Adapter(Current360v *p360v)  
    {  
        m_p = p360v;  
    }  
    void useCurrent()  
    {  
        cout << "adapter中使用电流" << endl;  
        m_p->useCurrent();  
    }  
protected:  
private:  
    CurrentAll *m_p;  
};  
  
void main()  
{  
  
    Current18v *p18v = new Current18v;  
    Adapter *padapter2 = new Adapter(p18v);  
    padapter2->useCurrent();  
  
    Current220v *p220v = new Current220v;  
    Adapter *padapter1 = new Adapter(p220v);  
    padapter1->useCurrent();  
      
    Current360v *p360v = new Current360v;  
    Adapter *padapter3 = new Adapter(p360v);  
    padapter3->useCurrent();  
  
    delete p220v;  
    delete padapter1;  
    delete p18v;  
    delete padapter2;  
    delete p360v;  
    delete padapter3;  
    system("pause");  
    return ;  
}  

四、观察者模式
概念：
观察者模式是一种行为模式，它的作用是当一个对象的状态发生变化时，能够自动通知其他关联对象，自动刷新对象状态。
提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。

应用：
1.侦听事件驱动程序设计中的外部事件
2.侦听/监视某个对象的状态变化
3.发布者/订阅者(publisher/subscriber)模型中，当一个外部事件（新的产品，消息的出现等等）被触发时，通知邮件列表中的订阅者

实例：
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Secretary;

//观察者
class PlayserObserver
{
public:
	PlayserObserver(string name, Secretary *secretary)
	{
		m_name = name;
		m_secretary = secretary;
	}
	void update(string action)
	{
		cout << "观察者收到消息:" << action << endl;
	}
private:
	string		m_name;
	Secretary	*m_secretary;
};

//通知者
class Secretary
{
public:
	void addObserver(PlayserObserver *o)
	{
		v.push_back(o);
	}
	void Notify(string action)
	{
		for (vector<PlayserObserver *>::iterator it= v.begin(); it!=v.end(); it++ )
		{
			(*it)->update(action);
		}
	}
	void setAction(string action)
	{
		m_action = action;
		Notify(m_action);
	}
private:
	string m_action;
	vector<PlayserObserver *> v;//需要维护的队列
};

void main()
{
	//通知者
	Secretary *s1 = new Secretary;

	//具体观察者 被通知对象
	PlayserObserver *po1 = new PlayserObserver("同事1", s1);
	PlayserObserver *po2 = new PlayserObserver("同事2", s1);
	s1->addObserver(po1);//当有新对象创建时，加入被通知队列
	s1->addObserver(po2);
	s1->setAction("放假了");
	while(1);
	return ;
}

五、桥接模式bridge
概念：
桥接模式是构造型的设计模式之一。Bridge模式基于类的最小设计原则，遵循开闭原则(类的改动通过增加代码来实现，而不是修改源代码),通过使用封装，聚合以及继承等行为来让不同的类承担不同的责任。它的主要特点是把抽象（abstraction）与行为实现（implementation）分离开来，
从而可以保持各部分的独立性以及应对它们的功能扩展。

接口实现：
Client 使用者
Abstraction base 抽象基类接口 (内含Implementor base 成员类)
Abstraction 抽象子类 (通过构造分配不同的行为，从而实现不同的行为)
Implementor base 行为实现基类接口
Implementor 行为实现子类

优势：
当抽象类需要更换行为时，不需要添加额外代码即可立即实现。

实现：
#include "stdafx.h"
#include <iostream>
using namespace std;
//把抽象（各个课程类） 和 行为实现（使用语言上课） 分开
//语言是一个名次，专门抽象成一个类；类中含有一个成员函数，使用它来上课

class Language//语言基类
{
public:
	virtual void useLanguage() = 0;//使用各种语言接口
};

class Chinese : public Language
{
public:
	virtual void useLanguage()
	{
		cout << "使用了中文" << endl;
	}
};

class English : public Language
{
public:
	virtual void useLanguage()
	{
		cout << "使用了英语" << endl;
	}
};

class Course //各个课程的课程基类
{
public:
	Course(Language *_lang)
	{
		m_lang = _lang;
	}
	virtual void useLanguage() = 0;

protected:
	Language *m_lang;//包含语言这个行为
};

class Math :public Course
{
public:
	Math(Language *p) : Course(p){ }

	virtual void useLanguage()
	{
		cout << "数学课 " ; 
		m_lang->useLanguage();
	}
};

class Physics:public Course
{
public:
	Physics(Language *p) : Course(p){ }

	virtual void useLanguage()
	{
		cout << "物理课 " ; 
		m_lang->useLanguage();
	}
};

void main()
{
	Chinese *_ch = new Chinese;
	Math *_ma = new Math(_ch);
	_ma->useLanguage();

	English *_Eng = new English;
	Physics *_ph = new Physics(_Eng);
	_ph->useLanguage();
	delete _ch;
	delete _ma;
	delete _Eng;
	delete _ph;
	system("pause");
}

六、策略模式Strategy
概念:
行为模式之一，它对一系列的算法或实现进行封装，为所有算法或实现定义统一接口，并通过继承该抽象接口对所有的实现加以封装和实现，
具体的实现选择交由客户端决定（策略）。Strategy模式主要用来平滑地处理算法或各种实现的切换。

结构：
Strategy: 各种实现的抽象基类。
ConcreteStrategy：各种实现的具体子类
Context： 策略的外壳，或者说策略的容器类。根据不同策略执行不同的行为。

适用于：
	一般用于一组实现，用其进行封装后，当调用实现后方便于各个实现进行相互调换。


实例：
#include "stdafx.h"
#include <iostream>
using namespace std;
class Strategy
{
public:
	virtual void SymEncrypt() = 0;
};

class Way1 : public Strategy
{
public:
	virtual void UseWays()
	{
		cout << "方式1" << endl; 
	}
};

class Way2 : public Strategy
{
public:
	virtual void UseWays()
	{
		cout << "方式2" << endl; 
	}
};


class Context
{
public:
	Context(Strategy *strategy)
	{
		p = strategy;
	}
	void Operator()//操作
	{
		p->UseWays();
	}
private:
	Strategy *p;
};

void main()
{
	Strategy *strategy = NULL;
	Context *ctx = NULL;

	strategy = new Way1;//在这儿可以动态决定使用的方法
	ctx = new Context(strategy);
	ctx->Operator();
	delete strategy;
	delete ctx;

	system("pause");
	return ;
}

七、迭代器模式iterator
概念：
Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。

结构：
Iterator（迭代器接口）： 该类定义实现迭代功能的最小定义方法集，比如提供hasNext()和next()方法。
ConcreteIterator（迭代器实现类）：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
Aggregate（容器基类接口）：定义基本功能以及提供CreateIterator()接口。
concreteAggregate（容器实现类）：容器接口的实现类。必须实现CreateIterator()方法。

用法：
Iterator模式是为了按照一定的顺序进行遍历访问容器的一种设计模式。简单地说，Iterator模式提供一种有效的方法，
可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。

实例：
#include "stdafx.h"
#include <iostream>
using namespace std;

//注意类的顺序 
class Iterator
{
public:
	virtual void First() = 0;
	virtual void Next() = 0;
	virtual bool IsEnd() = 0;
	virtual int CurrentItem() = 0;
};

class Aggregate
{
public:
	virtual int getItem(int index) = 0;
	virtual Iterator *CreateIterator() = 0;
	virtual int getSize() = 0;
};

class ContreteIterator : public Iterator
{
public:
	ContreteIterator(Aggregate *ag) 
	{
		_ag = ag;
		_idx = 0;
	}
	~ContreteIterator()
	{
		_ag = NULL;
		_idx = 0;
	}

	virtual void First()
	{
		_idx = 0;
	}
	virtual void Next()
	{
		if (_idx <	_ag->getSize())
		{
			_idx ++;
		}
	}
	virtual bool IsEnd()
	{
		return (_idx == _ag->getSize());
	}
	virtual int CurrentItem()
	{
		return _ag->getItem(_idx);
	}

protected:
private:
	int			_idx;
	Aggregate	*_ag;
};

class ConcreteAggregate : public Aggregate
{
public:
	ConcreteAggregate()
	{
		for (int i=0; i<SIZE; i++)
		{
			object[i] = i+1;
		}
	}
	virtual ~ConcreteAggregate()
	{

	}
	virtual int getItem(int index)
	{
		return object[index];
	}
	virtual Iterator *CreateIterator()
	{
		return new ContreteIterator(this);
	}
	virtual int getSize()
	{
		return SIZE;
	}
protected:
private:
	const static int  SIZE = 5;
	int object[SIZE];
};

void main()
{
	// 创建一个集合
	Aggregate *ag = new ConcreteAggregate();
	// 创建一个遍历这个集合的 迭代器

	auto it = ag->CreateIterator();
	//通过迭代器 遍历 集合
	for (; !(it->IsEnd()); it->Next() )
	{
		cout << it->CurrentItem() << " ";
	}

	//清理相关资源 
	delete it;
	delete ag;
	system("pause");
	return ;
}


























































